/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#include "stdafx.h"
#include "MBT_Engine.h"

#include "底层绘图/intern/绘图框架.h"

#include <malloc.h>
#include <atomic>
#include <chrono>
#include <locale>
#include <map>
#include <thread>
#include <vector>
#include "shader_binding_ID.h"
#include "shader_built_in_functions.h"
#include "shader_curve.h"
#include "shader_mesh.h"
#include "shader_ray.h"
#include "shader_std.h"
#include "texture.h"
#include "引擎配置.h"
#include "设备内存缓存.h"
#include "UI/Widget.h"
#include "底层绘图/S_纹理.h"
#include "底层绘图/底层绘图框架.h"
#include "引擎数据类型.h"
#include "引擎枚举数据.h"
#include "材质/材质.h"
#include "物体/S_物体.h"
#include "物体/物体.h"
#include "窗口/窗口.h"
#include "纹理/纹理.h"
#include "缓存.h"
#include "面/Mesh.h"
#include "面/Surface.h"
#include "面/面.h"
#include <basic_def.h>
#include <basic_vec.h>


#include "spdlog\spdlog.h"
#include "spdlog\sinks\rotating_file_sink.h"




extern "C" { 

	#include "引擎枚举数据.h"
	#include "basic_typedef.h"
	#include "engine_export.h"

}

using namespace std;




static S_Mesh* g预设图形网格 = nullptr;

S_UI渲染环境*  S_Engine::m_UIctx = nullptr;
bool           S_Engine::m_资源加载线程 = true;
bool           S_Engine::g_渲染线程 = true;
atomic_int32_t S_Engine::g_在运行线程 = 0;

map<uint64, S_Window*> S_Engine::g_窗口容器;

S_后期处理		S_Engine::g_后期处理{};


S_结构对象* S_Engine::g_场景阴影纹理布局 = nullptr;
S_结构对象* S_Engine::g_场景环境渲染参数布局 = nullptr;
S_结构对象* S_Engine::g_场景几何纹理渲染布局 = nullptr;
//暂时无用
S_结构对象* S_Engine::g_光栅最终渲染参数布局 = nullptr;


S_帧缓存* S_Engine::g_阴影帧缓存512 = nullptr;
S_帧缓存* S_Engine::g_阴影帧缓存1024 = nullptr;
S_帧缓存* S_Engine::g_阴影帧缓存2048 = nullptr;
S_帧缓存* S_Engine::g_阴影帧缓存4096 = nullptr;
S_帧缓存* S_Engine::g_阴影帧缓存8192 = nullptr;

std::map<uint32, S_几何图形缓存*> g_几何缓存;

static std::shared_ptr<spdlog::logger> g_记录日志 = nullptr;


static bool f_engine_gen几何图形缓存(S_设备环境& ctx, uint16 物理设备ID, uint16 逻辑设备ID) {
	uint32 key = (物理设备ID<<16) | 逻辑设备ID;
	bool 新建 = false;
	assert(g_几何缓存.find(key) == g_几何缓存.end());
	auto b = g_几何缓存[key];
	
	if (!b) {
		b = (S_几何图形缓存*)calloc(1,sizeof(S_几何图形缓存));
		g_几何缓存[key] = b;

		uint32 Flags = E_板载缓存类型::e_着色端内存地址;
		b->m_平面图形GPU缓存_顶点 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_VBO, E_板载缓存类型::e_VBO | Flags, sizeof(mat2), 0);
		b->m_平面图形GPU缓存_索引 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_INDEX, E_板载缓存类型::e_INDEX | Flags, sizeof(uint32), 1);
		b->m_平面图形GPU缓存_序列元素 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_INDIRECT, E_板载缓存类型::e_INDIRECT | Flags, sizeof(S_VkDrawIndirectCommand), 1);
		b->m_平面图形GPU缓存_索引元素 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_INDIRECT, E_板载缓存类型::e_INDIRECT | Flags, sizeof(S_VkDrawIndexedIndirectCommand), 1);
		b->m_平面图形GPU缓存_渐变颜色 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(S_2D_EffectLinearGradient), 1);
		b->m_平面图形GPU缓存_效果控制 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(S_2D_EffectControl), 1);

		b->m_2D面板变换G = f_buf_create板载缓存(ctx, sizeof(mat3), E_板载缓存类型::e_SSBO, 1);
		b->m_2D面板变换L = f_buf_create板载缓存(ctx, sizeof(mat3), E_板载缓存类型::e_SSBO, 1);
		b->m_2D面板颜色 = f_buf_create板载缓存(ctx, sizeof(uvec2), E_板载缓存类型::e_SSBO, 1);
		b->m_2D凸包图元属性 = f_buf_create板载缓存(ctx, sizeof(S_2DConvexRect), E_板载缓存类型::e_SSBO, 1);
		b->m_2DGPU缓存_采样纹理ID = f_buf_create板载缓存(ctx, sizeof(uint32), E_板载缓存类型::e_SSBO, 1);


		b->m_3DGPU缓存_顶点 = f_buffer_创建流(ctx, E_板载缓存类型::e_VBO, sizeof(mat3));
		b->m_3DGPU缓存_索引 = f_buffer_创建流(ctx, E_板载缓存类型::e_INDEX, sizeof(uint32));
		b->m_3DGPU缓存_变换 = f_buf_create板载缓存(ctx, sizeof(mat4), E_板载缓存类型::e_SSBO, 1);
		b->m_3DGPU缓存_面颜色 = f_buf_create板载缓存(ctx, sizeof(uint32), E_板载缓存类型::e_SSBO, 1);

		b->m_UI模糊采样器 = f_tex_创建纹理采样器(ctx, {E_纹理拉伸方式::e_边缘, E_纹理拉伸方式::e_边缘, E_纹理拉伸方式::e_边缘});
		
		新建 = true;
	}
	ctx.m_几何图形 = b;
	return 新建;
}

static void f_engine_del几何图形缓存(S_设备环境& ctx, uint16 物理设备ID, uint16 逻辑设备ID) {
	for (auto& e : g_几何缓存) {
		f_buf_release板载缓存(e.second->m_2D面板变换G);
		f_buf_release板载缓存(e.second->m_2D面板变换L);
		f_buf_release板载缓存(e.second->m_2D面板颜色);
		f_buf_release板载缓存(e.second->m_2D凸包图元属性);
		f_buf_release板载缓存(e.second->m_2DGPU缓存_采样纹理ID);

		f_buf_release板载缓存(e.second->m_平面图形GPU缓存_顶点);
		f_buf_release板载缓存(e.second->m_平面图形GPU缓存_索引);

		f_buf_release板载缓存(e.second->m_平面图形GPU缓存_序列元素);
		f_buf_release板载缓存(e.second->m_平面图形GPU缓存_索引元素);
		f_buf_release板载缓存(e.second->m_平面图形GPU缓存_渐变颜色);
		f_buf_release板载缓存(e.second->m_平面图形GPU缓存_效果控制);


		f_buf_release板载缓存(e.second->m_3DGPU缓存_顶点);
		f_buf_release板载缓存(e.second->m_3DGPU缓存_索引);
		f_buf_release板载缓存(e.second->m_3DGPU缓存_变换);
		f_buf_release板载缓存(e.second->m_3DGPU缓存_面颜色);


		f_tex_销毁纹理采样器(e.second->m_UI模糊采样器);
	}
}


S_Engine::S_Engine() {
	std::locale::global(std::locale("zh_CN.UTF-8"));
	g_引擎配置.f_初始化着色器文件路径();

	m_绘图框架 = 0;
	m_UIctx = nullptr;

	f_window_Init();

	g_记录日志 = spdlog::rotating_logger_mt(
		"rotating_logger",  // 日志器名称
		(S_引擎配置::g_程序路径 / "logs/app.log").generic_string(),     // 基础路径和文件名
		10 * 1024 * 1024,   // 单个文件最大大小（10MB）
		20                  // 保留的历史文件数量
	);
	g_记录日志->set_level(spdlog::level::debug);
}

S_Engine::~S_Engine() {
	
}




void S_Engine::f_InitDX12() {
	m_绘图框架 = f_创建绘图框架(E_绘图API::E_DirectX12);
	m_API_Name = E_绘图API::E_DirectX12;
}

void S_Engine::f_InitVK() {
	m_绘图框架 = f_创建绘图框架(E_绘图API::E_Vulkan);
	m_API_Name = E_绘图API::E_Vulkan;

	S_UI渲染环境::f_初始化预设图元();

	uint32 num = m_绘图框架->m_设备.size();
	for (uint32 i = 0; i < num; ++i) {
		f_创建绘图设备(i);
	}

}

void S_Engine::f_CloseVK() {
	S_UI渲染环境::f_销毁绘图资源();
}



S_设备 S_Engine::f_get设备(uint32 物理设备ID) {
	if (m_绘图框架) {
		return m_绘图框架->m_设备[物理设备ID];
	}
	return S_设备();
}


S_设备 S_Engine::f_get光追设备() {
	uint32 num = m_绘图框架->m_设备.size();
	for (uint32 i = 0; i < num; ++i) {
		if (f_device_是否支持光追(m_绘图框架->m_设备[i])) {
			return m_绘图框架->m_设备[i];
		}
	}
	return S_设备();
}

S_设备 S_Engine::f_get设备() {
	return f_get最强计算性能设备(m_绘图框架->m_设备);
}

S_设备环境	S_Engine::f_gen光追设备环境(uint32 逻辑设备ID) {
	uint32 num = m_绘图框架->m_设备.size();

	bool 创建新数据 = false;

	S_设备环境 设备环境{};
	for (uint32 i = 0; i < num; ++i) {
		设备环境 = { m_绘图框架->m_Type, m_绘图框架->m_设备[i].物理设备, m_绘图框架->m_设备[i].逻辑设备[逻辑设备ID] };
		if (f_device_是否支持光追(m_绘图框架->m_设备[i])) {
			设备环境.m_支持光追 = true;
			创建新数据 = f_engine_gen几何图形缓存(设备环境, i, 逻辑设备ID);
			break;
		}
	}
	设备环境.m_绘图框架 = m_绘图框架;

	if (创建新数据) {
		f_surface_创建2D绘制预设形状缓存(设备环境);
		f_pipe_着色参数设置创建(设备环境);
	}
	
	DEF_记录日志("构建渲染环境");

	return 设备环境;
}

S_设备环境 S_Engine::f_gen设备环境(S_设备& 设备) {
	S_设备环境 设备环境 = { m_绘图框架->m_Type, 设备.物理设备, 设备.逻辑设备.front()};
	设备环境.m_支持光追 = false;
	设备环境.m_绘图框架 = m_绘图框架;
	bool 创建新数据 = f_engine_gen几何图形缓存(设备环境, 设备.物理设备.ID, 设备.逻辑设备.front().队列族索引);

	if (创建新数据) {
		f_surface_创建2D绘制预设形状缓存(设备环境);
		f_pipe_着色参数设置创建(设备环境);
	}

	DEF_记录日志("构建渲染环境");
	return 设备环境;
}

void S_Engine::f_del设备环境(S_设备环境& ctx) {
	f_df_销毁2D绘制缓存(ctx);
	f_surface_销毁2D绘制预设形状缓存(ctx);
}

S_逻辑设备 S_Engine::f_创建绘图设备(uint32 物理设备ID) {
	auto 物理设备 = m_绘图框架->f_取物理设备(物理设备ID);
	auto 逻辑设备 = m_绘图框架->f_创建图形逻辑设备(物理设备, f_device_是否支持光追(物理设备));
	if (逻辑设备.设备) {
		m_绘图框架->m_设备[物理设备ID].逻辑设备.push_back(逻辑设备);
	}
	return 逻辑设备;
}

void S_Engine::f_asynLoop() {
}

void S_Engine::f_Close(S_设备环境& ctx) {
	for (auto& e : C_Widget::g_键位映射容器) {
		free(e);
	}
	C_Widget::g_键位映射容器.clear();
	S_Engine::g_窗口容器.clear();
}

void S_Engine::f_initGPU参数内存(S_设备环境& ctx) {
	
}

void S_Engine::f_释放线程数据() {
	m_资源加载线程 = false;
	g_渲染线程 = false;

	for (uint32 i = 0; i < 1000; ++i) {
		if (S_Engine::g_在运行线程 > 0) {
			std::this_thread::sleep_for(std::chrono::milliseconds(30));
		}
		else {
			break;
		}
	}
}

void S_Engine::f_释放设备数据() {
	
}


S_Mesh* S_Engine::f_get预设图形网格() {
	return g预设图形网格;
}

void S_Engine::f_记录日志(const std::string info) {
	g_记录日志->info(info);
	g_记录日志->flush();
}

void f_logs_writeFile(const std::string& info) {
	S_Engine::f_记录日志(info);
}






S_帧渲染层* f_create帧渲染层(C_Widget管理& gm, S_Scene* scene) {
	S_帧渲染层* rl = (S_帧渲染层*)malloc(sizeof(S_帧渲染层));

	rl->m_Scene = (S_结构指针)scene;

	auto* face = f_surface_Create(gm.m_UICtx->m_Ctx, { 1024, 576 }, true);
	rl->m_Surface3D = (S_结构指针)face;

	f_tex_安装纹理采样器(face->m_Color[0], gm.m_UICtx->m_Mat->m_采样器);
	f_tex_安装纹理采样器(face->m_Color[1], gm.m_UICtx->m_Mat->m_采样器);
	f_tex_安装纹理采样器(face->m_Color[2], gm.m_UICtx->m_Mat->m_采样器);

	return rl;
}




S_Engine* f_engine_创建(E_绘图API type) {
	S_Engine* engine = new S_Engine();

	engine->f_InitVK();

	return engine;
}

void f_engine_销毁(S_Engine* engine) {
	f_buf_释放所有();

	engine->f_CloseVK();

	delete engine;
}


void f_engine_创建3D缓存(S_设备环境& ctx, bool 启用光追) {
	
	//f_engine_gen几何图形缓存(ctx, 0, 0);

	//uint32 Flags = E_板载缓存类型::e_着色端内存地址 | E_板载缓存类型::e_TBOs | E_板载缓存类型::e_TBOd;
	uint32 Flags = E_板载缓存类型::e_着色端内存地址;


	if (启用光追 && ctx.m_支持光追) {
		f_buf_getGlobal().g_光追物体实例属性ID = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(S_RtOb), 1);
		f_buf_getGlobal().g_顶层加速结构构建缓存 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_图像缓存 | Flags, 1, 1);

		DEF_记录日志("创建光追缓存");
	}
	else {
		f_buf_getGlobal().g_光追物体实例属性ID = nullptr;
	}


	/******************************** 采样器 *******************************/
	f_g_纹理().g_阴影采样器 = f_tex_创建阴影纹理采样器(ctx);
	f_g_纹理().g_颜色纹理采样器 = f_tex_创建颜色纹理采样器(ctx);
	f_g_纹理().g_平铺纹理采样器 = f_tex_创建平铺纹理采样器(ctx);
	DEF_记录日志("创建采样器");


	//================================= 物体数据初始化 ===================================
	//f_buf_getGlobal().g_变换矩阵 = f_buf_create板载缓存(ctx, sizeof(Mat44f), E_板载缓存类型::e_SSBO);
	S_物体::g_骨骼姿态 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(S_BonePose), 1);

	f_buf_getGlobal().g_物体颜色.resize(10);
	for (uint32 i = 0; i < 10; ++i) {
		f_buf_getGlobal().g_物体颜色[i] = f_buf_create板载缓存(ctx, sizeof(uint32), E_板载缓存类型::e_SSBO);
	}

	f_buf_getGlobal().g_实例材质ID = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(uint32), 1);
	f_buf_getGlobal().g_材质 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(S_Material), 0);
	f_buf_getGlobal().m_材质 = f_bm_alloc(f_buf_getGlobal().g_材质, 1);

	f_buf_getGlobal().m_几何属性 = f_buf_create板载缓存(ctx, sizeof(S_Geom), E_板载缓存类型::e_SSBO, 1);
	


	f_buf_getGlobal().m_场景物体网格属性 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO, sizeof(S_ObMesh), 1);
	f_buf_getGlobal().m_全局绑定参数指针 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(S_GlobalParam), 1);
	f_buf_getGlobal().g_全局绑定参数 = f_bm_alloc(f_buf_getGlobal().m_全局绑定参数指针, 1);

	f_buf_getGlobal().m_I32动态属性 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(int32), 1);
	f_buf_getGlobal().m_UI32动态属性 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(uint32), 1);
	f_buf_getGlobal().g_UI64缓存 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(uint64), 1);
	f_buf_getGlobal().m_F32动态属性 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(float32), 1);
	f_buf_getGlobal().m_Vec2动态属性 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(vec2), 1);
	f_buf_getGlobal().m_Vec3动态属性 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(vec3), 1);
	f_buf_getGlobal().m_Vec4动态属性 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(vec4), 1);

	f_buf_getGlobal().m_iVec2动态属性 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(ivec2), 1);
	f_buf_getGlobal().m_iVec3动态属性 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(ivec3), 1);
	f_buf_getGlobal().m_iVec4动态属性 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(ivec4), 1);

	f_buf_getGlobal().m_uVec2动态属性 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(uvec2), 1);
	f_buf_getGlobal().m_uVec3动态属性 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(uvec3), 1);
	f_buf_getGlobal().m_uVec4动态属性 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(uvec4), 1);

	f_buf_getGlobal().m_Mat44动态属性 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(Mat44f), 1);
	f_buf_getGlobal().m_U_Mat44 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_UBO, E_板载缓存类型::e_UBO, sizeof(Mat44f), 1);

	f_buf_getGlobal().g_采样曲线属性 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(S_CurvePoint2), 1);
	f_buf_getGlobal().g_纹理属性 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(S_TextueProp), 1);


	/********************************************************** 灯光数据缓存 ********************************************************/
	f_buf_getGlobal().m_平行光缓冲区 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(S_LightParallel), 1);
	f_buf_getGlobal().m_点光源缓冲区 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(S_LightPoint), 1);
	f_buf_getGlobal().m_区域光缓冲区 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(S_LightArea), 1);
	f_buf_getGlobal().m_聚光灯缓冲区 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(S_LightSpot), 1);
	f_buf_getGlobal().m_平行光缓冲区->m_Size = 0;
	f_buf_getGlobal().m_点光源缓冲区->m_Size = 0;
	//f_buf_getGlobal().m_区域光缓冲区->m_Size = 0;
	f_buf_getGlobal().m_聚光灯缓冲区->m_Size = 0;
	
	f_buf_getGlobal().m_灯光索引 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(S_LightIndex), 1);
	f_buf_getGlobal().g_灯光投影矩阵 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(Mat44f), 1);



	f_buf_getGlobal().g_MPM_坐标 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(vec3), 1);
	f_buf_getGlobal().g_PHY_前一帧坐标 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(vec3), 1);
	f_buf_getGlobal().g_PHY_速度和年龄 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(vec4), 1);
	f_buf_getGlobal().g_MPM_密度_lambda = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(vec3), 1);
	f_buf_getGlobal().g_MPM_速度梯度 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(vec3), 1);
	f_buf_getGlobal().g_PHY_压力 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(float32), 1);
	f_buf_getGlobal().m_Delta = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(vec3), 1);
	f_buf_getGlobal().g_PHY_粒子类型和状态 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(S_ParticleAttr), 1);

	f_buf_getGlobal().g_MPM_网格速度 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(vec3), 1);
	f_buf_getGlobal().g_MPM_网格密度 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(vec3), 1);

	f_buf_getGlobal().g_PHY_排序键值 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(uvec2), 1);
	f_buf_getGlobal().g_PHY_排序临时键值 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(uvec2), 1);
	f_buf_getGlobal().g_PHY_排序键值偏移A = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(uvec2), 1);
	f_buf_getGlobal().g_PHY_排序键值偏移B = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(uvec2), 1);
	f_buf_getGlobal().g_PHY_排序键值数量 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(uvec2), 1);
	f_buf_getGlobal().g_PHY_粒子网格索引 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(uvec2), 1);
	f_buf_getGlobal().g_PHY_飞溅排序键值 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(uint32), 1);
	f_buf_getGlobal().g_PHY_PBF参数 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(S_PBF_Params), 1);

	f_buf_getGlobal().g_PHY_飞溅坐标 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(vec3), 1);
	f_buf_getGlobal().g_PHY_飞溅速度 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(vec4), 1);
	f_buf_getGlobal().g_PHY_飞溅粒子寿命 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(float32), 1);

	f_buf_getGlobal().g_PHY_飞溅粒子发射排序键值 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(uint32), 1);
	f_buf_getGlobal().g_PHY_飞溅粒子发射区间数量 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(uvec2), 1);

	f_buf_getGlobal().g_PHY_物理力 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(S_PBF_force), 1);

	f_buf_getGlobal().g_粒子位置 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(vec3), 1);
	f_buf_getGlobal().g_粒子速度 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(vec3), 1);
	f_buf_getGlobal().g_粒子旋转 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(vec3), 1);
	f_buf_getGlobal().g_粒子大小 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(float32), 1);


	f_buf_getGlobal().g_自定义属性索引 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(S_CustomAttr), 1);
	f_buf_getGlobal().g_顶点v = f_buf_create板载缓存(ctx, E_板载缓存类型::e_VBO, E_板载缓存类型::e_VBO | E_板载缓存类型::e_光追BVH | Flags, sizeof(vec3), 1);
	f_buf_getGlobal().g_顶点vn = f_buf_create板载缓存(ctx, E_板载缓存类型::e_VBO, E_板载缓存类型::e_VBO | E_板载缓存类型::e_光追BVH | Flags, sizeof(S_VN), 1);
	f_buf_getGlobal().g_顶点vc = f_buf_create板载缓存(ctx, E_板载缓存类型::e_VBO, E_板载缓存类型::e_VBO | E_板载缓存类型::e_光追BVH | Flags, sizeof(S_VC), 1);
	f_buf_getGlobal().g_顶点vnt = f_buf_create板载缓存(ctx, E_板载缓存类型::e_VBO, E_板载缓存类型::e_VBO | E_板载缓存类型::e_光追BVH | Flags, sizeof(S_VNT1), 1);
	f_buf_getGlobal().g_索引_A = f_buf_create板载缓存(ctx, E_板载缓存类型::e_INDEX, E_板载缓存类型::e_INDEX | E_板载缓存类型::e_光追BVH | Flags, sizeof(uint32), 1);
	f_buf_getGlobal().g_索引_B = f_buf_create板载缓存(ctx, E_板载缓存类型::e_INDEX, E_板载缓存类型::e_INDEX | E_板载缓存类型::e_光追BVH | Flags, sizeof(uint32), 1);

	f_buf_getGlobal().g_全局模型纹理槽 = f_纹理槽_创建(1);



	//============================ 平面部分 ===================================
	f_buf_getGlobal().g顶点 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_VBO, E_板载缓存类型::e_VBO | E_板载缓存类型::e_SSBO, sizeof(S_2D图元顶点), 1);
	f_buf_getGlobal().g索引 = f_buf_create板载缓存(ctx, sizeof(uint32), E_板载缓存类型::e_INDEX, 1);
	f_buf_getGlobal().g间接 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_INDIRECT, E_板载缓存类型::e_INDIRECT | Flags, sizeof(S_VkDrawIndirectCommand), 1);
	f_buf_getGlobal().g2D层 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, E_板载缓存类型::e_SSBO | Flags, sizeof(float32), 1);




	f_surface_初始化网格GPU内存(ctx);



	/************************************* 材质属性 **********************************/
	f_buf_getGlobal().g_全局纹理属性 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_UBO, E_板载缓存类型::e_UBO | Flags, sizeof(S_GlobalAtt_RasterPostCompositing), 1);
	


	/************************************* 缺损纹理 **********************************/
	S_全局缓存::g_默认采样器 = f_tex_创建纹理采样器(ctx);
	S_全局缓存::g_空纹理 = f_tex_创建图像纹理(ctx, { 16,16,1 }, E_纹理格式::e_tf_RGBA8U_归一化, E_纹理维度类型::e_2D);
	f_tex_安装纹理采样器(S_全局缓存::g_空纹理, S_全局缓存::g_默认采样器);
	

	std::vector<S_RGBA8UI> 默认字符纹理填充(16 * 16);
	f_tex_填充纹理数据(S_全局缓存::g_空纹理, (uint8*)默认字符纹理填充.data(), sizeof(S_RGBA8UI), { 16,16,1 });
	f_tex_读写布局(S_全局缓存::g_空纹理);

	f_g_纹理().g_缺损阴影纹理 = f_tex_创建深度纹理(ctx, _uVec3(_uVec2(8), 1), E_MS次数::e_MS_1);
	f_tex_安装纹理采样器(f_g_纹理().g_缺损阴影纹理, f_g_纹理().g_阴影采样器);

	f_g_纹理().g_缺损立方体阴影纹理 = f_tex_创建深度纹理(ctx, _uVec3(_uVec2(8), 1), E_MS次数::e_MS_1, E_纹理维度类型::e_CUBE);
	f_tex_安装纹理采样器(f_g_纹理().g_缺损立方体阴影纹理, f_g_纹理().g_阴影采样器);

	f_g_纹理().g_缺损方体纹理 = f_tex_创建图像纹理(ctx, _uVec3(_uVec2(8), 1), E_纹理格式::e_tf_RGBA8U_归一化, E_纹理维度类型::e_CUBE, E_MS次数::e_MS_1);
	f_tex_安装纹理采样器(f_g_纹理().g_缺损方体纹理, f_g_纹理().g_颜色纹理采样器);


	//S_Mesh::g_透明链表计数 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_UBO, E_板载缓存类型::e_UBO | E_板载缓存类型::e_着色端内存地址, sizeof(uint32), 1);
	f_buf_getGlobal().g_透明链表计数 = f_bm_alloc(f_buf_getGlobal().m_UI32动态属性, 2);
	f_buf_getGlobal().g_透明链表纹理 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_图像缓存, E_板载缓存类型::e_图像缓存, sizeof(uint32) * 4, 1);
	f_buf_getGlobal().g_透明链表头 = f_tex_创建图像纹理(ctx, { 16,16,1 }, E_纹理格式::e_tf_R32U, E_纹理维度类型::e_2D);
	f_tex_安装纹理采样器(f_buf_getGlobal().g_透明链表头, S_全局缓存::g_默认采样器);


	f_g_纹理().g_GBuffer_顶点坐标 = f_tex_创建帧缓存纹理(ctx, { 2,2,1 }, E_纹理格式::e_tf_RGBA32, E_纹理维度类型::e_2D);
	f_g_纹理().g_GBuffer_法线阴影 = f_tex_创建帧缓存纹理(ctx, { 2,2,1 }, E_纹理格式::e_tf_RGBA32, E_纹理维度类型::e_2D);
	f_tex_安装纹理采样器(f_g_纹理().g_GBuffer_顶点坐标, S_全局缓存::g_默认采样器);
	f_tex_安装纹理采样器(f_g_纹理().g_GBuffer_法线阴影, S_全局缓存::g_默认采样器);


	

	return;

	f_buf_getGlobal().m_2D线 = f_buf_create板载缓存(ctx, sizeof(S_2D线), E_板载缓存类型::e_VBO, 1);
	f_buf_getGlobal().g_字符纹理UV = f_buf_create板载缓存(ctx, sizeof(ivec4), E_板载缓存类型::e_SSBO, 1);
	f_buf_getGlobal().g_字符 = f_buf_create板载缓存(ctx, sizeof(int32), E_板载缓存类型::e_SSBO, 1);
	f_buf_getGlobal().g_凸包图元 = f_buf_create板载缓存(ctx, sizeof(S_2D图元顶点), E_板载缓存类型::e_VBO, 1);
	f_buf_getGlobal().g_凸包图元区域 = f_buf_create板载缓存(ctx, sizeof(S_2DConvexRect), E_板载缓存类型::e_SSBO, 1);
	f_buf_getGlobal().g_波形属性 = f_buf_create板载缓存(ctx, sizeof(S_Waveform), E_板载缓存类型::e_SSBO, 1);
	
	
}

void f_engine_销毁3D缓存(S_设备环境& ctx) {

	f_material_销毁预设材质();


	/******************************** 阴影帧缓存 *******************************/
	//f_fb_销毁帧缓存(S_Engine::g_阴影帧缓存512);
	//f_fb_销毁帧缓存(S_Engine::g_阴影帧缓存1024);
	//f_fb_销毁帧缓存(S_Engine::g_阴影帧缓存2048);
	//f_fb_销毁帧缓存(S_Engine::g_阴影帧缓存4096);
	//f_fb_销毁帧缓存(S_Engine::g_阴影帧缓存8192);




	//f_df_销毁绑定参数布局(ctx, S_Engine::g_摄像机GPU布局描述);
	//f_df_销毁绑定参数布局(ctx, S_Engine::g_场景环境渲染参数布局);
	//f_df_销毁绑定参数布局(ctx, S_Engine::g_场景几何纹理渲染布局);
	//f_df_销毁绑定参数布局(ctx, S_Engine::g_光栅最终渲染参数布局);

	//f_df_销毁绑定参数布局(ctx, C_Widget管理::g_UI投影布局描述);

	//f_df_销毁并行计算(S_Engine::g_后期处理.g_光栅阴影计算);
	//f_df_销毁并行计算(S_Engine::g_后期处理.g_光栅后期合成);


	/************************************* 材质属性 **********************************/
	f_buf_release板载缓存(f_buf_getGlobal().g_全局纹理属性);
	



	f_surface3d_释放GPU内存();



	/************************************* 缺损纹理 **********************************/
	f_tex_销毁纹理采样器(S_全局缓存::g_默认采样器);

	f_tex_销毁纹理采样器(f_g_纹理().g_阴影采样器);
	f_tex_销毁纹理采样器(f_g_纹理().g_颜色纹理采样器);
	f_tex_销毁纹理采样器(f_g_纹理().g_平铺纹理采样器);
	//f_tex_销毁纹理(f_g_纹理().g_GBuffer_顶点坐标);
	//f_tex_销毁纹理(f_g_纹理().g_GBuffer_法线阴影);
	//f_tex_销毁纹理(f_g_纹理().g_缺损立方体阴影纹理);
	//f_tex_销毁纹理(f_g_纹理().g_缺损阴影纹理);

	f_buf_release板载缓存(f_buf_getGlobal().g_透明链表纹理);
	//f_tex_销毁纹理(f_buf_getGlobal().g_透明链表头);
	//f_tex_销毁纹理(S_全局缓存::g_空纹理);

	f_纹理槽_销毁(f_buf_getGlobal().g_全局模型纹理槽);


	//============================ 平面部分 ===================================
	f_buf_release板载缓存(f_buf_getGlobal().g顶点);
	f_buf_release板载缓存(f_buf_getGlobal().g索引);
	f_buf_release板载缓存(f_buf_getGlobal().g间接);
	f_buf_release板载缓存(f_buf_getGlobal().g2D层);





	//f_buf_release板载缓存(f_buf_getGlobal().g_变换矩阵);

	f_buf_release板载缓存(f_buf_getGlobal().m_几何属性);
	f_buf_release板载缓存(f_buf_getGlobal().m_2D线);
	//f_buf_release板载缓存(f_buf_getGlobal().m_2D面板变换);
	f_buf_release板载缓存(f_buf_getGlobal().g_字符纹理UV);
	f_buf_release板载缓存(f_buf_getGlobal().g_字符);
	f_buf_release板载缓存(f_buf_getGlobal().g_凸包图元);
	f_buf_release板载缓存(f_buf_getGlobal().g_凸包图元区域);
	f_buf_release板载缓存(f_buf_getGlobal().g_波形属性);


	f_buf_release板载缓存(f_buf_getGlobal().g_实例材质ID);

	f_buf_release板载缓存(f_buf_getGlobal().m_全局绑定参数指针);
	f_buf_release板载缓存(f_buf_getGlobal().m_I32动态属性);
	f_buf_release板载缓存(f_buf_getGlobal().m_UI32动态属性);
	f_buf_release板载缓存(f_buf_getGlobal().g_UI64缓存);
	f_buf_release板载缓存(f_buf_getGlobal().m_F32动态属性);
	f_buf_release板载缓存(f_buf_getGlobal().m_Vec2动态属性);
	f_buf_release板载缓存(f_buf_getGlobal().m_Vec3动态属性);
	f_buf_release板载缓存(f_buf_getGlobal().m_Vec4动态属性);

	f_buf_release板载缓存(f_buf_getGlobal().m_iVec2动态属性);
	f_buf_release板载缓存(f_buf_getGlobal().m_iVec3动态属性);
	f_buf_release板载缓存(f_buf_getGlobal().m_iVec4动态属性);

	f_buf_release板载缓存(f_buf_getGlobal().m_uVec2动态属性);
	f_buf_release板载缓存(f_buf_getGlobal().m_uVec3动态属性);
	f_buf_release板载缓存(f_buf_getGlobal().m_uVec4动态属性);

	f_buf_release板载缓存(f_buf_getGlobal().m_Mat44动态属性);

	f_buf_release板载缓存(f_buf_getGlobal().g_采样曲线属性);
	f_buf_release板载缓存(f_buf_getGlobal().g_纹理属性);


	f_buf_release板载缓存(f_buf_getGlobal().m_平行光缓冲区);
	f_buf_release板载缓存(f_buf_getGlobal().m_点光源缓冲区);
	f_buf_release板载缓存(f_buf_getGlobal().m_区域光缓冲区);
	f_buf_release板载缓存(f_buf_getGlobal().m_聚光灯缓冲区);
	f_buf_release板载缓存(f_buf_getGlobal().m_灯光索引);
	f_buf_release板载缓存(f_buf_getGlobal().g_灯光投影矩阵);



	f_buf_release板载缓存(f_buf_getGlobal().g_MPM_坐标);
	f_buf_release板载缓存(f_buf_getGlobal().g_PHY_前一帧坐标);
	f_buf_release板载缓存(f_buf_getGlobal().g_PHY_速度和年龄);
	f_buf_release板载缓存(f_buf_getGlobal().g_MPM_密度_lambda);
	f_buf_release板载缓存(f_buf_getGlobal().g_MPM_速度梯度);
	f_buf_release板载缓存(f_buf_getGlobal().g_MPM_网格速度);
	f_buf_release板载缓存(f_buf_getGlobal().g_MPM_网格密度);
	f_buf_release板载缓存(f_buf_getGlobal().g_PHY_压力);
	f_buf_release板载缓存(f_buf_getGlobal().m_Delta);

	f_buf_release板载缓存(f_buf_getGlobal().g_PHY_排序键值);
	f_buf_release板载缓存(f_buf_getGlobal().g_PHY_排序临时键值);
	f_buf_release板载缓存(f_buf_getGlobal().g_PHY_排序键值偏移A);
	f_buf_release板载缓存(f_buf_getGlobal().g_PHY_排序键值偏移B);
	f_buf_release板载缓存(f_buf_getGlobal().g_PHY_排序键值数量);

	f_buf_release板载缓存(f_buf_getGlobal().g_粒子位置);
	f_buf_release板载缓存(f_buf_getGlobal().g_粒子速度);
	f_buf_release板载缓存(f_buf_getGlobal().g_粒子旋转);
	f_buf_release板载缓存(f_buf_getGlobal().g_粒子大小);

	f_buf_release板载缓存(f_buf_getGlobal().g_PHY_物理力);


	


	//============================ 网格部分 ===================================
	f_buf_release板载缓存(f_buf_getGlobal().g_顶点v);
	f_buf_release板载缓存(f_buf_getGlobal().g_顶点vn);
	f_buf_release板载缓存(f_buf_getGlobal().g_顶点vc);
	f_buf_release板载缓存(f_buf_getGlobal().g_顶点vnt);
	f_buf_release板载缓存(f_buf_getGlobal().g_索引_A);
	f_buf_release板载缓存(f_buf_getGlobal().g_索引_B);

	f_buf_release板载缓存(f_buf_getGlobal().g_UV坐标);
	f_buf_release板载缓存(f_buf_getGlobal().g_UV索引);
	f_buf_release板载缓存(f_buf_getGlobal().g_面);
	f_buf_release板载缓存(f_buf_getGlobal().g_邻接面索引);
	f_buf_release板载缓存(f_buf_getGlobal().g_面法线);
	f_buf_release板载缓存(f_buf_getGlobal().g_面中心);

	f_buf_release板载缓存(f_buf_getGlobal().g_BLAS_0);
	f_buf_release板载缓存(f_buf_getGlobal().g_BLAS_1);
	f_buf_release板载缓存(f_buf_getGlobal().g_TLAS_0);
	f_buf_release板载缓存(f_buf_getGlobal().g_TLAS_1);
	f_buf_release板载缓存(f_buf_getGlobal().g_实例AS_0);
	f_buf_release板载缓存(f_buf_getGlobal().g_实例AS_1);
	f_buf_release板载缓存(f_buf_getGlobal().g_RtMesh);

	f_buf_release板载缓存(f_buf_getGlobal().g_骨骼属性);
	f_buf_release板载缓存(f_buf_getGlobal().g_骨骼权重);

	f_buf_release板载缓存(f_buf_getGlobal().g_间接);
	f_buf_release板载缓存(f_buf_getGlobal().g_索引间接);



	for (auto& e : f_buf_getGlobal().g_物体颜色) {
		f_buf_release板载缓存(e);
	}



	/*********************************** 光追缓存 *********************************************/
	if (ctx.m_支持光追) {
		f_buf_release板载缓存(f_buf_getGlobal().g_顶层加速结构构建缓存);
		f_buf_release板载缓存(f_buf_getGlobal().g_光追物体实例属性ID);
	}


}



void f_engine_创建2D缓存(S_设备环境& ctx, bool 启用光追) {

}

void f_engine_销毁2D缓存(S_设备环境& ctx) {

}


void f_engine_初始化材质数据(S_设备环境& ctx, bool 启用光追) {
	f_material_销毁预设材质();
	f_material_创建预设材质(ctx);
}

void f_engine_创建光栅渲染(S_设备环境& ctx) {
	//std::vector<S_着色器创建参数> 参数布局;
	//参数布局 = { {0, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO} };
	//S_Engine::g_摄像机GPU布局描述 = f_df_创建着色器参数布局(f_df_getVK设备(ctx), 参数布局, nullptr);


	std::vector<S_着色器创建参数> 阴影渲染 = {
		{DEF_BindID_GlobalTextAtt,				E_着色阶段::e_像素着色, E_板载缓存类型::e_UBO},
	};
	S_Engine::g_场景阴影纹理布局 = f_df_创建着色器参数布局(f_df_getVK设备(ctx), 阴影渲染, nullptr);


	std::vector<S_着色器创建参数> 环境渲染 = {
		{DEF_BINDING_TasterBindID_MaterialID,	E_着色阶段::e_像素着色, E_板载缓存类型::e_SSBO},
	};
	S_Engine::g_场景环境渲染参数布局 = f_df_创建着色器参数布局(f_df_getVK设备(ctx), 环境渲染, nullptr);


	std::vector<S_着色器创建参数> 环境后期处理 = {
		{0,			E_着色阶段::e_计算着色, E_板载缓存类型::e_IMAGE_SAMPLER},
		{1,			E_着色阶段::e_计算着色, E_板载缓存类型::e_IMAGE},
		{2,			E_着色阶段::e_计算着色, E_板载缓存类型::e_IMAGE},
	};
	const std::vector<S_常量推送创建参数> 环境后期合成常量 = {
		{E_着色阶段::e_计算着色, 0, sizeof(S_ConstPush_AmbientBlur)},
	};
	S_Engine::g_后期处理.g_光栅环境后期 = f_df_创建并行计算(ctx, S_引擎配置::m_3D着色器文件根路径 + "环境纹理模糊.cspv", 环境后期处理, 环境后期合成常量, true);


	std::vector<S_着色器创建参数> 几何渲染 = {
		{DEF_BindID_GlobalTextAtt,			E_着色阶段::e_像素着色, E_板载缓存类型::e_UBO},
		{DEF_BindID_TextureShadow,			E_着色阶段::e_像素着色, E_板载缓存类型::e_IMAGE_SAMPLER},
		{DEF_BindID_TextureCube,			E_着色阶段::e_像素着色, E_板载缓存类型::e_IMAGE_SAMPLER},
		{DEF_BindID_TexCubeShadow,			E_着色阶段::e_像素着色, E_板载缓存类型::e_IMAGE_SAMPLER},

		{DEF_BindID_TexShadow_LightIndex,	E_着色阶段::e_像素着色, E_板载缓存类型::e_SSBO},
		{DEF_BindID_TexShadow_PVMatrix,		E_着色阶段::e_像素着色, E_板载缓存类型::e_SSBO},
		{DEF_BindID_TexShadow_AreaLight,	E_着色阶段::e_像素着色, E_板载缓存类型::e_SSBO},
	};
	S_Engine::g_场景几何纹理渲染布局 = f_df_创建着色器参数布局(f_df_getVK设备(ctx), 几何渲染, nullptr);


	std::vector<S_着色器创建参数> 光栅阴影计算 = {
		{DEF_BindID_TexShadow_LightIndex,	E_着色阶段::e_计算着色, E_板载缓存类型::e_SSBO},
		{DEF_BindID_TexShadow_PVMatrix,		E_着色阶段::e_计算着色, E_板载缓存类型::e_SSBO},
		{DEF_BindID_TexShadow_AreaLight,	E_着色阶段::e_计算着色, E_板载缓存类型::e_SSBO},

		{DEF_BindID_TextureShadow,		E_着色阶段::e_计算着色, E_板载缓存类型::e_IMAGE_SAMPLER},
		{DEF_BindID_GBufferImage,		E_着色阶段::e_计算着色, E_板载缓存类型::e_IMAGE_SAMPLER},
		{DEF_BindID_CompositingShadow,	E_着色阶段::e_计算着色, E_板载缓存类型::e_IMAGE},
	};
	const std::vector<S_常量推送创建参数> 后期合成常量 = {
		{E_着色阶段::e_计算着色, 0, sizeof(S_GlobalAtt_RasterPostCompositing)},
	};
	S_Engine::g_后期处理.g_光栅阴影计算 = f_df_创建并行计算(ctx, S_引擎配置::m_3D着色器文件根路径 + "光栅阴影计算.cspv", 光栅阴影计算, 后期合成常量, true);
	S_Engine::g_后期处理.g_光栅后期合成 = f_df_创建并行计算(ctx, S_引擎配置::m_3D着色器文件根路径 + "光栅后期合成.cspv", 光栅阴影计算, 后期合成常量, true);



	std::vector<S_着色器创建参数> 最终渲染 = {
		{DEF_BindID_GlobalTextAtt,				E_着色阶段::e_像素着色, E_板载缓存类型::e_UBO},
		{DEF_BindID_TexShadow_LightIndex,		E_着色阶段::e_像素着色, E_板载缓存类型::e_SSBO},
		{DEF_BindID_TexShadow_PVMatrix,			E_着色阶段::e_像素着色, E_板载缓存类型::e_SSBO},
		{DEF_BindID_TexShadow_AreaLight,		E_着色阶段::e_像素着色, E_板载缓存类型::e_SSBO},
		{DEF_BINDING_TasterBindID_MaterialID,	E_着色阶段::e_像素着色, E_板载缓存类型::e_SSBO},


		{DEF_BindID_TextureCube,				E_着色阶段::e_像素着色, E_板载缓存类型::e_IMAGE_SAMPLER},
		{DEF_BindID_TextureShadow,				E_着色阶段::e_像素着色, E_板载缓存类型::e_IMAGE_SAMPLER},
		{DEF_BindID_TexCubeShadow,				E_着色阶段::e_像素着色, E_板载缓存类型::e_IMAGE_SAMPLER},
		{DEF_BindID_GBufferImage,				E_着色阶段::e_像素着色, E_板载缓存类型::e_IMAGE_SAMPLER},

		{DEF_BindID_CompositingShadow,			E_着色阶段::e_像素着色, E_板载缓存类型::e_IMAGE_SAMPLER},
	};
	S_Engine::g_光栅最终渲染参数布局 = f_df_创建着色器参数布局(f_df_getVK设备(ctx), 最终渲染, nullptr);



	//参数布局 = { {DEF_BINDING_PROJECT, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO} };
	//C_Widget管理::g_UI投影布局描述 = f_df_创建着色器参数布局(f_df_getVK设备(ctx), 参数布局, nullptr);


}

void f_engine_销毁光栅渲染(S_设备环境& ctx) {

}


S_GPU参数槽 f_engine_环境渲染参数槽布局2() {
	S_GPU参数槽 环境渲染参数槽 = {};
	f_df_allocGPU参数缓存槽(&环境渲染参数槽, 1);
	环境渲染参数槽.m_GPU布局描述 = S_Engine::g_场景环境渲染参数布局;


	//环境渲染参数槽.m_参数槽[0] = f_buf_getGlobal().g_全局纹理属性;
	//环境渲染参数槽.m_参数类型[0] = E_板载缓存类型::e_UBO;
	//环境渲染参数槽.m_绑定位置[0] = DEF_BindID_GlobalTextAtt;
	//环境渲染参数槽.m_绑定数量[0] = 1;
	//
	//环境渲染参数槽.m_参数槽[1] = f_buf_getGlobal().m_灯光索引;
	//环境渲染参数槽.m_参数类型[1] = E_板载缓存类型::e_SSBO;
	//环境渲染参数槽.m_绑定位置[1] = DEF_BindID_TexShadow_LightIndex;
	//环境渲染参数槽.m_绑定数量[1] = 1;
	//
	//环境渲染参数槽.m_参数槽[2] = f_buf_getGlobal().m_区域光缓冲区;
	//环境渲染参数槽.m_参数类型[2] = E_板载缓存类型::e_SSBO;
	//环境渲染参数槽.m_绑定位置[2] = DEF_BindID_TexShadow_AreaLight;
	//环境渲染参数槽.m_绑定数量[2] = 1;
	//
	//环境渲染参数槽.m_参数槽[3] = f_buf_getGlobal().g_灯光投影矩阵;
	//环境渲染参数槽.m_参数类型[3] = E_板载缓存类型::e_SSBO;
	//环境渲染参数槽.m_绑定位置[3] = DEF_BindID_TexShadow_PVMatrix;
	//环境渲染参数槽.m_绑定数量[3] = 1;

	环境渲染参数槽.m_参数槽[0] = f_buf_getGlobal().g_材质;
	环境渲染参数槽.m_参数类型[0] = E_板载缓存类型::e_SSBO;
	环境渲染参数槽.m_绑定位置[0] = DEF_BINDING_TasterBindID_MaterialID;
	环境渲染参数槽.m_绑定数量[0] = 1;

	return 环境渲染参数槽;
}

S_GPU参数槽 f_engine_环境后期参数槽布局0() {
	S_GPU参数槽 环境渲染参数槽 = {};
	f_df_allocGPU参数缓存槽(&环境渲染参数槽, 2);
	环境渲染参数槽.m_GPU布局描述 = S_Engine::g_后期处理.g_光栅环境后期->m_参数布局;

	return 环境渲染参数槽;
}

S_GPU参数槽 f_engine_几何渲染参数槽布局0() {
	S_GPU参数槽 几何渲染参数槽 = {};
	f_df_allocGPU参数缓存槽(&几何渲染参数槽, 4);
	几何渲染参数槽.m_GPU布局描述 = S_Engine::g_场景几何纹理渲染布局;

	几何渲染参数槽.m_参数槽[0] = f_buf_getGlobal().g_全局纹理属性;
	几何渲染参数槽.m_参数类型[0] = E_板载缓存类型::e_UBO;
	几何渲染参数槽.m_绑定位置[0] = DEF_BindID_GlobalTextAtt;
	几何渲染参数槽.m_绑定数量[0] = 1;

	几何渲染参数槽.m_参数槽[1] = f_buf_getGlobal().m_灯光索引;
	几何渲染参数槽.m_参数类型[1] = E_板载缓存类型::e_SSBO;
	几何渲染参数槽.m_绑定位置[1] = DEF_BindID_TexShadow_LightIndex;
	几何渲染参数槽.m_绑定数量[1] = 1;

	几何渲染参数槽.m_参数槽[2] = f_buf_getGlobal().m_区域光缓冲区;
	几何渲染参数槽.m_参数类型[2] = E_板载缓存类型::e_SSBO;
	几何渲染参数槽.m_绑定位置[2] = DEF_BindID_TexShadow_AreaLight;
	几何渲染参数槽.m_绑定数量[2] = 1;

	几何渲染参数槽.m_参数槽[3] = f_buf_getGlobal().g_灯光投影矩阵;
	几何渲染参数槽.m_参数类型[3] = E_板载缓存类型::e_SSBO;
	几何渲染参数槽.m_绑定位置[3] = DEF_BindID_TexShadow_PVMatrix;
	几何渲染参数槽.m_绑定数量[3] = 1;

	return 几何渲染参数槽;
}

S_GPU参数槽 f_engine_最终渲染参数槽布局2(){
	//auto 最终渲染纹理槽 = f_tex_创建纹理槽(0);

	//m_环境纹理集 = f_纹理集_创建();
	//f_纹理集_add纹理(m_环境纹理集, S_节点数据::g_缺损环境颜色纹理);
	//
	//m_立方体阴影纹理集 = f_纹理集_创建();
	//f_纹理集_add纹理(m_立方体阴影纹理集, S_节点数据::g_缺损立方体阴影纹理);


	//f_纹理槽_设置纹理集(m_最终渲染纹理槽, m_环境纹理集, 0, DEF_BindID_TextureCube);
	//f_纹理槽_设置纹理集(m_最终渲染纹理槽, m_深度阴影纹理集, 1, DEF_BindID_TextureShadow);
	//f_纹理槽_设置纹理集(m_最终渲染纹理槽, m_立方体阴影纹理集, 2, DEF_BindID_TexCubeShadow);
	//f_纹理槽_设置纹理集(m_最终渲染纹理槽, m_屏幕后期阴影纹理集, 3, DEF_BindID_CompositingShadow);
	//f_纹理槽_设置纹理集(m_最终渲染纹理槽, m_屏幕后期几何纹理集, 4, DEF_BindID_GBufferImage);


	S_GPU参数槽 最终渲染参数槽 = {};
	f_df_allocGPU参数缓存槽(&最终渲染参数槽, 5);
	最终渲染参数槽.m_GPU布局描述 = S_Engine::g_光栅最终渲染参数布局;


	最终渲染参数槽.m_参数槽[0] = f_buf_getGlobal().g_全局纹理属性;
	最终渲染参数槽.m_参数类型[0] = E_板载缓存类型::e_UBO;
	最终渲染参数槽.m_绑定位置[0] = DEF_BindID_GlobalTextAtt;
	最终渲染参数槽.m_绑定数量[0] = 1;

	最终渲染参数槽.m_参数槽[1] = f_buf_getGlobal().m_灯光索引;
	最终渲染参数槽.m_参数类型[1] = E_板载缓存类型::e_SSBO;
	最终渲染参数槽.m_绑定位置[1] = DEF_BindID_TexShadow_LightIndex;
	最终渲染参数槽.m_绑定数量[1] = 1;

	最终渲染参数槽.m_参数槽[2] = f_buf_getGlobal().m_区域光缓冲区;
	最终渲染参数槽.m_参数类型[2] = E_板载缓存类型::e_SSBO;
	最终渲染参数槽.m_绑定位置[2] = DEF_BindID_TexShadow_AreaLight;
	最终渲染参数槽.m_绑定数量[2] = 1;

	最终渲染参数槽.m_参数槽[3] = f_buf_getGlobal().g_灯光投影矩阵;
	最终渲染参数槽.m_参数类型[3] = E_板载缓存类型::e_SSBO;
	最终渲染参数槽.m_绑定位置[3] = DEF_BindID_TexShadow_PVMatrix;
	最终渲染参数槽.m_绑定数量[3] = 1;

	最终渲染参数槽.m_参数槽[4] = f_buf_getGlobal().g_材质;
	最终渲染参数槽.m_参数类型[4] = E_板载缓存类型::e_SSBO;
	最终渲染参数槽.m_绑定位置[4] = DEF_BINDING_TasterBindID_MaterialID;
	最终渲染参数槽.m_绑定数量[4] = 1;

	//最终渲染参数槽.m_纹理槽 = &最终渲染纹理槽;


	return 最终渲染参数槽;
}


S_GPU参数槽 f_engine_后期光影计算参数槽布局0() {
	S_GPU参数槽 后期光影计算参数槽 = {};
	f_df_allocGPU参数缓存槽(&后期光影计算参数槽, 3);
	后期光影计算参数槽.m_GPU布局描述 = S_Engine::g_后期处理.g_光栅阴影计算->m_参数布局;


	后期光影计算参数槽.m_参数槽[0] = f_buf_getGlobal().m_灯光索引;
	后期光影计算参数槽.m_参数类型[0] = E_板载缓存类型::e_SSBO;
	后期光影计算参数槽.m_绑定位置[0] = DEF_BindID_TexShadow_LightIndex;
	后期光影计算参数槽.m_绑定数量[0] = 1;

	后期光影计算参数槽.m_参数槽[1] = f_buf_getGlobal().m_区域光缓冲区;
	后期光影计算参数槽.m_参数类型[1] = E_板载缓存类型::e_SSBO;
	后期光影计算参数槽.m_绑定位置[1] = DEF_BindID_TexShadow_AreaLight;
	后期光影计算参数槽.m_绑定数量[1] = 1;

	后期光影计算参数槽.m_参数槽[2] = f_buf_getGlobal().g_灯光投影矩阵;
	后期光影计算参数槽.m_参数类型[2] = E_板载缓存类型::e_SSBO;
	后期光影计算参数槽.m_绑定位置[2] = DEF_BindID_TexShadow_PVMatrix;
	后期光影计算参数槽.m_绑定数量[2] = 1;


	return 后期光影计算参数槽;
}

S_GPU参数槽 f_engine_后期屏幕效果合成参数槽布局0() {
	S_GPU参数槽 后期屏幕效果合成参数槽 = {};
	f_df_allocGPU参数缓存槽(&后期屏幕效果合成参数槽, 0);
	后期屏幕效果合成参数槽.m_GPU布局描述 = S_Engine::g_后期处理.g_光栅后期合成->m_参数布局;


	//后期屏幕效果合成参数槽.m_参数槽[0] = f_buf_getGlobal().m_灯光索引;
	//后期屏幕效果合成参数槽.m_参数类型[0] = E_板载缓存类型::e_SSBO;
	//后期屏幕效果合成参数槽.m_绑定位置[0] = DEF_BindID_TexShadow_LightIndex;
	//后期屏幕效果合成参数槽.m_绑定数量[0] = 1;
	//
	//后期屏幕效果合成参数槽.m_参数槽[1] = f_buf_getGlobal().m_区域光缓冲区;
	//后期屏幕效果合成参数槽.m_参数类型[1] = E_板载缓存类型::e_SSBO;
	//后期屏幕效果合成参数槽.m_绑定位置[1] = DEF_BindID_TexShadow_AreaLight;
	//后期屏幕效果合成参数槽.m_绑定数量[1] = 1;
	//
	//后期屏幕效果合成参数槽.m_参数槽[2] = f_buf_getGlobal().g_灯光投影矩阵;
	//后期屏幕效果合成参数槽.m_参数类型[2] = E_板载缓存类型::e_SSBO;
	//后期屏幕效果合成参数槽.m_绑定位置[2] = DEF_BindID_TexShadow_PVMatrix;
	//后期屏幕效果合成参数槽.m_绑定数量[2] = 1;


	return 后期屏幕效果合成参数槽;
}



S_灯光系统* f_engine_创建灯光系统() {
	S_灯光系统* ls = (S_灯光系统*)calloc(1, sizeof(S_灯光系统));

	ls->m_灯光属性ID = f_bm_alloc(f_buf_getGlobal().m_灯光索引, 0);
	ls->m_深度阴影纹理集 = f_纹理集_创建();

	return ls;
}

void f_engine_组织灯光阴影纹理(S_灯光系统* ls, S_物体** 灯光物体, uint32 num) {
	std::vector<S_纹理*> 阴影纹理;

	f_bm_resize(ls->m_灯光属性ID, num);
	auto* 灯光索引 = f_bm_ptr<S_LightIndex>(ls->m_灯光属性ID);


	for (uint32 i = 0; i < num; ++i) {
		auto light = f_ob_get子对象(灯光物体[i], 0);
		auto* lp = f_ob_getLigth(light);


		灯光索引[i].m_lightType = lp->m_灯光类型;
		灯光索引[i].m_attIndex = lp->m_灯光数据.m_Mem.m_偏移;

		auto l = f_bm_at<S_LightArea>(lp->m_灯光数据);

		灯光索引[i].m_shadowTexIndex = 阴影纹理.size();
		灯光索引[i].m_matrixIndex = lp->m_灯光阴影矩阵.m_Mem.m_偏移;

		for (uint32 光采样ID = 0; 光采样ID < lp->m_阴影图->count; ++光采样ID) {
			auto* arce = lp->m_阴影图->ptr_userData[光采样ID];

			阴影纹理.push_back(arce);
		}
	}


	f_纹理集_set数量(ls->m_深度阴影纹理集, 阴影纹理.size());
	for (uint32 i = 0; i < 阴影纹理.size(); ++i) {
		f_纹理集_set纹理(ls->m_深度阴影纹理集, 阴影纹理[i], i);
	}
}

